double[] (Groovy JDK enhancements)

primitives.double[]

```
public class double[]
extends Object
```
GDK enhancements for double[].
displayName:
double[]
receiverFqcn:
double[]

Methods Summary

Methods
Type Params	Return Type	Name and description
	`public boolean`	`any(Closure<?> predicate)` Iterates over the contents of a double Array, and checks whether a predicate is valid for at least one element.
	`public boolean`	`asBoolean()` Coerces a double array to a boolean value.
	`public double`	`average()` Calculates the average of the doubles in the array.
	`public List<List<Double>>`	`chop(int chopSizes)` Chops the double array into pieces, returning lists with sizes corresponding to the supplied chop sizes.
	`public boolean`	`contains(Object value)` Checks whether the array contains the given value.
	`public Number`	`count(Object value)` Counts the number of occurrences of the given value inside this array.
	`public DoubleStream`	`doubleStream()` Returns a sequential DoubleStream with the specified array as its source.
	`public double[]`	`each(DoubleConsumer consumer)` Iterates through a double[] passing each double to the given consumer.
	`public double[]`	`eachWithIndex(Closure<?> closure)` Iterates through a double[], passing each double and the element's index (a counter starting at zero) to the given closure.
	`public boolean`	`equals(double[] right)` Compares the contents of this array to the contents of the given array.
	`public boolean`	`every(Closure<?> predicate)` Iterates over the contents of a double Array, and checks whether a predicate is valid for all elements.
	`public double`	`first()` Returns the first item from the double array.
	`public List<Double>`	`flatten()` Flattens an array.
	`public List<Double>`	`getAt(Range<?> range)` Supports the subscript operator for a double array with a range giving the desired indices.
	`public List<Double>`	`getAt(IntRange range)` Supports the subscript operator for a double array with an IntRange giving the desired indices.
	`public List<Double>`	`getAt(ObjectRange range)` Supports the subscript operator for a double array with an ObjectRange giving the desired indices.
	`public List<Double>`	`getAt(Collection<?> indices)` Supports the subscript operator for a double array with a (potentially nested) collection giving the desired indices.
	`public IntRange`	`getIndices()` Returns indices of the double array.
	`public String`	`groovyToString()` Returns Groovy's list-like string representation for a double array.
	`public double`	`head()` Returns the first item from the double array.
	`public Map<Integer, Double>`	`indexed()` Zips a double[] with indices in (index, value) order starting from index 0.
	`public Map<Integer, Double>`	`indexed(int offset)` Zips a double[] with indices in (index, value) order starting from a given index.
	`public double[]`	`init()` Returns the items from the double array excluding the last item.
	`public String`	`join()` Concatenates the string representation of each item in this array.
	`public String`	`join(String separator)` Concatenates the string representation of each item in this array, with the given String as a separator between each item.
	`public double`	`last()` Returns the last item from the double array.
	`public double`	`max()` Adds max() method to double arrays.
	`public double`	`max(DoubleComparator comparator)` Selects the maximum value found from the double array using the supplied DoubleComparator to determine the maximum of any two values.
	`public double`	`max(DoubleUnaryOperator operator)` Selects the maximum value found from the double array using the supplied DoubleUnaryOperator to determine the maximum of any two values.
	`public double`	`maxComparing(Comparator<Double> comparator)` Selects the maximum value found from the double array using the comparator to determine the maximum of any two values.
	`public double`	`min()` Adds min() method to double arrays.
	`public double`	`min(DoubleComparator comparator)` Selects the minimum value found from the double array using the supplied DoubleComparator to determine the minimum of any two values.
	`public double`	`min(DoubleUnaryOperator operator)` Selects the minimum value found from the double array using the supplied DoubleUnaryOperator to determine the minimum of any two values.
	`public double`	`minComparing(Comparator<Double> comparator)` Selects the minimum value found from the double array using the comparator to determine the minimum of any two values.
	`public int`	`partitionPoint(IntRange range, DoublePredicate condition)` Returns the index of the partition point according to the given predicate (the index of the first element of the second partition).
	`public int`	`partitionPoint(DoublePredicate condition)` Returns the index of the partition point according to the given predicate (the index of the first element of the second partition).
	`public void`	`putAt(IntRange range, double[] source)` A helper method to allow arrays to be set with subscript operators.
	`public void`	`putAt(IntRange range, Iterable<Number> source)` A helper method to allow arrays to be set with subscript operators.
	`public double[]`	`reverse()` Creates a new double array containing items which are the same as this array but in reverse order.
	`public double[]`	`reverse(boolean mutate)` Reverses the items in an array.
	`public double[]`	`reverseEach(Closure<?> closure)` Iterates through a double[] in reverse order passing each double to the given closure.
	`public int`	`size()` Provides arrays with a `size` method similar to collections.
	`public Stream<Double>`	`stream()` Returns a sequential Stream with the specified array as its source.
	`public double`	`sum()` Sums the items in an array.
	`public double`	`sum(DoubleUnaryOperator operator)` Calculates the sum of values found from applying the operator to members of the int array.
	`public double`	`sum(double initialValue)` Sums the items in an array, adding the result to some initial value.
	`public double[]`	`swap(int i, int j)` Swaps two elements at the specified positions.
	`public double[]`	`tail()` Returns the items from the double array excluding the first item.
	`public List<Double>`	`toList()` Converts this array to a List of the same size, with each element added to the list.
	`public Set<Double>`	`toSet()` Converts this array to a Set, with each unique element added to the set.
	`public String`	`toString()` Returns the string representation of the given array.
	`public List<Tuple2<Double, Integer>>`	`withIndex()` Zips a double array with indices in (value, index) order.
	`public List<Tuple2<Double, Integer>>`	`withIndex(int offset)` Zips a double array with indices in (value, index) order starting from a given index.
	`public List<Tuple2<Double, Double>>`	`zip(double[] other)` A list of all the pairs from two arrays.
	`public Iterator<Tuple2<Double, Double>>`	`zipping(double[] other)` An iterator of all the pairs from two arrays.

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class Object`	addShutdownHook, any, any, asBoolean, asType, collect, collect, collect, dump, each, eachMatch, eachMatch, eachWithIndex, every, every, find, find, findAll, findAll, findIndexOf, findIndexOf, findIndexValues, findIndexValues, findLastIndexOf, findLastIndexOf, findResult, findResult, findResult, findResult, getAt, getMetaClass, getMetaPropertyValues, getProperties, grep, grep, hasProperty, identity, inject, inject, inspect, invokeMethod, is, isCase, isNotCase, iterator, metaClass, print, print, printf, printf, println, println, println, putAt, respondsTo, respondsTo, setMetaClass, sleep, sleep, split, sprintf, sprintf, stream, tap, toString, use, use, use, with, with, withCloseable, withCloseable, withMethodClosure, withStream, withStream, withTraits

- Method Detail
  - public boolean any(Closure<?> predicate)
    
    Iterates over the contents of a double Array, and checks whether a predicate is valid for at least one element.
```
 double[] array = [0.0d, 1.0d, 2.0d]
 assert array.any{ it > 1.5d }
 assert !array.any{ it > 2.5d }
 
```
    Parameters:
    predicate - the closure predicate used for matching
    Returns:
    true if any iteration for the doubles matches the closure predicate
    Since:
    5.0.0
  - public boolean asBoolean()
    
    Coerces a double array to a boolean value. A double array is false if the array is of length 0, and true otherwise.
    Returns:
    the array's boolean value
    Since:
    1.7.4
  - public double average()
    
    Calculates the average of the doubles in the array.
```
assert 5.0d == ([2,4,6,8] as double[]).average()
```
    Returns:
    The average of the items
    Since:
    3.0.0
  - public List<List<Double>> chop(int chopSizes)
    
    Chops the double array into pieces, returning lists with sizes corresponding to the supplied chop sizes. If the array isn't large enough, truncated (possibly empty) pieces are returned. Using a chop size of -1 will cause that piece to contain all remaining items from the array.
```
 double[] array = [0, 1, 2]
 assert array.chop(1, 2) == [[0], [1, 2]]
 
```
    Parameters:
    chopSizes - the sizes for the returned pieces
    Returns:
    a list of lists chopping the original array elements into pieces determined by chopSizes
    See Also:
    ArrayGroovyMethods#collate(Object[], int)#collate(Object[], int)
    Since:
    5.0.0
  - public boolean contains(Object value)
    
    Checks whether the array contains the given value.
    Parameters:
    value - the value being searched for
    Returns:
    true if the array contains the value
    Since:
    1.8.6
  - public Number count(Object value)
    
    Counts the number of occurrences of the given value inside this array. Comparison is done using Groovy's == operator (using compareTo(value) == 0).
```
 double[] array = [10.0d, 20.0d, 20.0d, 30.0d]
 assert array.count(20.0d) == 2
 
```
    Parameters:
    value - the value being searched for
    Returns:
    the number of occurrences
    See Also:
    DefaultGroovyMethods#count(Iterator, Object)#count(Iterator, Object)
    Since:
    1.6.4
  - public DoubleStream doubleStream()
    
    Returns a sequential DoubleStream with the specified array as its source.
    Returns:
    a Stream for the array
    Since:
    3.0.8
  - public double[] each(DoubleConsumer consumer)
    
    Iterates through a double[] passing each double to the given consumer.
```
 double[] array = [0d, 1d, 2d]
 String result = ''
 array.each{ result += it }
 assert result == '0.01.02.0'
 
```
    Parameters:
    consumer - the consumer for each double
    Returns:
    the self array
    Since:
    5.0.0
  - public double[] eachWithIndex(Closure<?> closure)
    
    Iterates through a double[], passing each double and the element's index (a counter starting at zero) to the given closure.
```
 double[] array = [10d, 20d, 30d]
 String result = ''
 array.eachWithIndex{ item, index -> result += "$index($item)" }
 assert result == '0(10.0)1(20.0)2(30.0)'
 
```
    Parameters:
    closure - a Closure to operate on each double
    Returns:
    the self array
    Since:
    5.0.0
  - public boolean equals(double[] right)
    
    Compares the contents of this array to the contents of the given array.
    Example usage:
```
 double[] array1 = [4.0d, 8.0d]
 double[] array2 = [4.0d, 8.0d]
 assert array1 !== array2
 assert array1.equals(array2)
 
```
    Parameters:
    right - the array being compared
    Returns:
    true if the contents of both arrays are equal.
    Since:
    5.0.0
  - public boolean every(Closure<?> predicate)
    
    Iterates over the contents of a double Array, and checks whether a predicate is valid for all elements.
```
 double[] array = [0.0d, 1.0d, 2.0d]
 assert array.every{ it < 2.5d }
 assert !array.every{ it > 1.5d }
 
```
    Parameters:
    predicate - the closure predicate used for matching
    Returns:
    true if the predicate returns true for all elements in the array
    Since:
    5.0.0
  - public double first()
    
    Returns the first item from the double array.
```
 double[] doubles = [10.0d, 20.0d, 30.0d]
 assert doubles.first() == 10.0d
 
```
    An alias for head().
    throws:
    NoSuchElementException if the array is empty
    
    Returns:
    the first element
    Since:
    5.0.0
  - public List<Double> flatten()
    
    Flattens an array. This array is added to a new collection. It is an alias for toList() but allows algorithms to be written which also work on multidimensional arrays or non-arrays where flattening would be applicable.
```
 double[] array = [0.0d, 1.0d]
 assert array.flatten() == [0.0d, 1.0d]
 
```
    Returns:
    a Collection of the array elements
    Since:
    1.6.0
  - public List<Double> getAt(Range<?> range)
    
    Supports the subscript operator for a double array with a range giving the desired indices.
```
 double[] array = [1.0d, 3.0d, 5.0d, 7.0d, 9.0d, 11.0d]
 assert array[2..<2] == [] // EmptyRange
 assert array[(0..5.5).step(2)] == [1.0d, 5.0d, 9.0d]   // NumberRange
 assert array[(1..5.5).step(2)] == [3.0d, 7.0d, 11.0d]  // NumberRange
 
```
    Parameters:
    range - a range indicating the indices for the items to retrieve
    Returns:
    list of the retrieved doubles
    Since:
    1.0
  - public List<Double> getAt(IntRange range)
    
    Supports the subscript operator for a double array with an IntRange giving the desired indices.
```
 double[] array = [0.0d, 10.0d, 20.0d, 30.0d, 40.0d]
 assert array[2..3] == [20.0d, 30.0d]
 assert array[-2..-1] == [30.0d, 40.0d]
 assert array[-1..-2] == [40.0d, 30.0d]
 
```
    Parameters:
    range - an IntRange indicating the indices for the items to retrieve
    Returns:
    list of the retrieved doubles
    Since:
    1.0
  - public List<Double> getAt(ObjectRange range)
    
    Supports the subscript operator for a double array with an ObjectRange giving the desired indices.
```
 double[] array = [0.0d, 10.0d, 20.0d, 30.0d, 40.0d]
 def range = new ObjectRange(2, 3)
 assert array[range] == [20.0d, 30.0d]
 
```
    Parameters:
    range - an ObjectRange indicating the indices for the items to retrieve
    Returns:
    list of the retrieved doubles
    Since:
    1.0
  - public List<Double> getAt(Collection<?> indices)
    
    Supports the subscript operator for a double array with a (potentially nested) collection giving the desired indices.
```
 double[] array = [0.0d, 2.0d, 4.0d, 6.0d, 8.0d]
 assert array[2, 3] == [4.0d, 6.0d]
 assert array[1, 0..1, [0, [-1]]] == [2.0d, 0.0d, 2.0d, 0.0d, 8.0d]
 
```
    Parameters:
    indices - a collection of indices for the items to retrieve
    Returns:
    list of the doubles at the given indices
    Since:
    1.0
  - public IntRange getIndices()
    
    Returns indices of the double array.
```
 double[] array = [0.0d, 1.0d]
 assert array.indices == 0..1
 
```
    See Also:
    ArrayGroovyMethods#getIndices(Object[])#getIndices(Object[])
    Since:
    3.0.8
  - public String groovyToString()
    
    Returns Groovy's list-like string representation for a double array.
    If disabled, e.g. via -Dgroovy.extension.disable=groovyToString(double[]), the JDK's default array toString() is used instead.
    Returns:
    the string representation
    Since:
    6.0.0
  - public double head()
    
    Returns the first item from the double array.
```
 double[] doubles = [10.0d, 20.0d, 30.0d]
 assert doubles.head() == 10.0d
 
```
    An alias for first().
    throws:
    NoSuchElementException if the array is empty
    
    Returns:
    the first element
    Since:
    5.0.0
  - public Map<Integer, Double> indexed()
    
    Zips a double[] with indices in (index, value) order starting from index 0.
    Example usage:
```
 double[] nums = [10.0d, 20.0d, 30.0d]
 assert [0: 10.0d, 1: 20.0d, 2: 30.0d] == nums.indexed()
 
```
    See Also:
    indexed(double[], int)
    Since:
    3.0.8
  - public Map<Integer, Double> indexed(int offset)
    
    Zips a double[] with indices in (index, value) order starting from a given index.
    Example usage:
```
 double[] nums = [10.0d, 20.0d, 30.0d]
 assert [5: 10.0d, 6: 20.0d, 7: 30.0d] == nums.indexed(5)
 
```
    Parameters:
    offset - an index to start from
    Returns:
    a Map (since the keys/indices are unique) containing the elements from the iterable zipped with indices
    See Also:
    DefaultGroovyMethods#indexed(Iterable, int)#indexed(Iterable, int)
    Since:
    3.0.8
  - public double[] init()
    
    Returns the items from the double array excluding the last item.
```
 double[] doubles = [10.0d, 20.0d, 30.0d]
 def result = doubles.init()
 assert result == [10.0d, 20.0d]
 assert doubles.class.componentType == result.class.componentType
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Returns:
    an array without its last element
    Since:
    5.0.0
  - public String join()
    
    Concatenates the string representation of each item in this array.
    Returns:
    the joined String
    Since:
    5.0.0
  - public String join(String separator)
    
    Concatenates the string representation of each item in this array, with the given String as a separator between each item.
    Parameters:
    separator - a String separator
    Returns:
    the joined String
    Since:
    2.4.1
  - public double last()
    
    Returns the last item from the double array.
```
 double[] doubles = [10.0d, 20.0d, 30.0d]
 assert doubles.last() == 30.0d
 
```
    throws:
    NoSuchElementException if the array is empty
    
    Returns:
    the last element
    Since:
    5.0.0
  - public double max()
    
    Adds max() method to double arrays.
    Example usage:
```
 double[] nums = [1.1d, 3.3d, 2.2d]
 assert 3.3d == nums.max()
 
```
    Returns:
    the maximum value
    Since:
    3.0.8
  - public double max(DoubleComparator comparator)
    
    Selects the maximum value found from the double array using the supplied DoubleComparator to determine the maximum of any two values.
```
 double[] nums = [10d, 20d, -30d]
 assert 20d == nums.max{ n, m -> n <=> m }
 assert -30d == nums.max{ n, m -> n.abs() <=> m.abs() }
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Parameters:
    comparator - a comparator, i.e. returns a negative value if the first parameter is less than the second
    Returns:
    the maximum value
    Since:
    5.0.0
  - public double max(DoubleUnaryOperator operator)
    
    Selects the maximum value found from the double array using the supplied DoubleUnaryOperator to determine the maximum of any two values. The operator is applied to each array element and the results are compared.
```
 double[] nums = [10d, 20d, -30d]
 assert -30d == nums.max{ it.abs() }
 assert 20d == nums.max{ it }
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Parameters:
    operator - an operator that returns a double used for comparing values
    Returns:
    the maximum value
    Since:
    5.0.0
  - public double maxComparing(Comparator<Double> comparator)
    
    Selects the maximum value found from the double array using the comparator to determine the maximum of any two values.
```
 double[] nums = [10.0d, 20.0d, 30.0d]
 assert 30d == nums.maxComparing(Comparator.naturalOrder())
 assert 10d == nums.maxComparing(Comparator.reverseOrder())
 
```
    Parameters:
    comparator - a Comparator
    Returns:
    the maximum value
    See Also:
    DefaultGroovyMethods#max(Iterator, java.util.Comparator)
    Since:
    5.0.0
  - public double min()
    
    Adds min() method to double arrays.
    Example usage:
```
 double[] nums = [20.0d, 10.0d, 30.0d]
 assert 10.0d == nums.min()
 
```
    Returns:
    the minimum value
    Since:
    3.0.8
  - public double min(DoubleComparator comparator)
    
    Selects the minimum value found from the double array using the supplied DoubleComparator to determine the minimum of any two values.
```
 double[] nums = [10d, -20d, 30d]
 assert -20d == nums.min{ n, m -> n <=> m }
 assert 10d == nums.min{ n, m -> n.abs() <=> m.abs() }
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Parameters:
    comparator - a comparator, i.e. returns a negative value if the first parameter is less than the second
    Returns:
    the minimum value
    Since:
    5.0.0
  - public double min(DoubleUnaryOperator operator)
    
    Selects the minimum value found from the double array using the supplied DoubleUnaryOperator to determine the minimum of any two values. The operator is applied to each array element and the results are compared.
```
 double[] nums = [10d, -20d, 30d]
 assert -20d == nums.min{ it }
 assert 10d == nums.min{ it.abs() }
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Parameters:
    operator - an operator that returns a double used for comparing values
    Returns:
    the minimum value
    Since:
    5.0.0
  - public double minComparing(Comparator<Double> comparator)
    
    Selects the minimum value found from the double array using the comparator to determine the minimum of any two values.
```
 double[] nums = [10.0d, 20.0d, 30.0d]
 assert 10d == nums.minComparing(Comparator.naturalOrder())
 assert 30d == nums.minComparing(Comparator.reverseOrder())
 
```
    Parameters:
    comparator - a Comparator
    Returns:
    the minimum value
    See Also:
    DefaultGroovyMethods#min(Iterator, java.util.Comparator)
    Since:
    5.0.0
  - public int partitionPoint(IntRange range, DoublePredicate condition)
    
    Returns the index of the partition point according to the given predicate (the index of the first element of the second partition). The arr is assumed to be partitioned according to the given predicate.
```
 def arr = [7, 15, 3, 5, 4, 12, 6] as double[]
 assert arr.partitionPoint(0..<arr.size()) { it%2 != 0 } == 4
 
```
```
 def arr = [1, 2, 3, 3, 4, 4, 5, 6, 7] as double[]
 // usage case like lower_bound(cpp), bisect_left(python)
 assert arr.partitionPoint(0..<arr.size()) { it < 4 } == 4
 // usage case like upper_bound(cpp), bisect_right(python)
 assert arr.partitionPoint(0..<arr.size()) { it <= 4 } == 6
 // for all match condition
 assert arr.partitionPoint(0..<arr.size()) { it <= 100 } == arr.size()
 // for all match condition
 assert arr.partitionPoint(0..<arr.size()) { it <= 0 } == 0
 // for no match condition with range
 assert arr.partitionPoint(2..<arr.size()) { it <= 0 } == 2
 
```
    Parameters:
    range - the range [l,r] to find data match the condition
    condition - the matching condition
    Returns:
    an integer that is the index of the first element of the second partition
    Since:
    5.0.0
  - public int partitionPoint(DoublePredicate condition)
    
    Returns the index of the partition point according to the given predicate (the index of the first element of the second partition). The arr is assumed to be partitioned according to the given predicate.
```
 def arr = [7, 15, 3, 5, 4, 12, 6] as double[]
 assert arr.partitionPoint{ it%2 != 0 } == 4
 
```
```
 def arr = [1, 2, 3, 3, 4, 4, 5, 6, 7] as double[]
 // usage case like lower_bound(cpp), bisect_left(python)
 assert arr.partitionPoint{ it < 4 } == 4
 // usage case like upper_bound(cpp), bisect_right(python)
 assert arr.partitionPoint{ it <= 4 } == 6
 // for all match condition
 assert arr.partitionPoint{ it <= 100 } == arr.size()
 // for no match condition
 assert arr.partitionPoint{ it <= 0 } == 0
 
```
    Parameters:
    condition - the matching condition
    Returns:
    an integer that is the index of the first element of the second partition
    Since:
    5.0.0
  - public void putAt(IntRange range, double[] source)
    
    A helper method to allow arrays to be set with subscript operators.
```
 double[] from = [1d, 1d, 1d]
 double[] to = [0d, 0d, 0d, 0d, 0d]
 to[1..3] = from
 assert to == [0d, 1d, 1d, 1d, 0d]
 
```
    throws:
    IndexOutOfBoundsException if the source doesn't have sufficient elements or the IntRange is too big for the self array
    
    Parameters:
    range - the subset of the array to set
    source - the source array from which new values will come
    Since:
    5.0.0
  - public void putAt(IntRange range, Iterable<Number> source)
    
    A helper method to allow arrays to be set with subscript operators. Zero will be used if the source iterable has insufficient elements.
```
 def from = [1d, 1d, 1d]
 double[] to = [0d, 0d, 0d, 0d, 0d]
 to[1..3] = from
 assert to == [0d, 1d, 1d, 1d, 0d]
 
```
    Parameters:
    range - the subset of the array to set
    source - the source array from which new values will come
    Since:
    5.0.0
  - public double[] reverse()
    
    Creates a new double array containing items which are the same as this array but in reverse order.
```
 double[] array = [1d, 2d]
 assert array.reverse() == [2d, 1d]
 
```
    Returns:
    an array containing the reversed items
    See Also:
    reverse(double[], boolean)
    Since:
    5.0.0
  - public double[] reverse(boolean mutate)
    
    Reverses the items in an array. If mutate is true, the original array is modified in place and returned. Otherwise, a new array containing the reversed items is produced.
```
 double[] array = 1d..3d
 def yarra = array.reverse(true)
 assert array == 3d..1d
 assert yarra == 3d..1d
 assert array === yarra
 yarra = array.reverse(false)
 assert array !== yarra
 assert array == 3d..1d
 assert yarra == 1d..3d
 
```
    Parameters:
    mutate - true if the array itself should be reversed in place, false if a new array should be created
    Returns:
    an array containing the reversed items
    Since:
    5.0.0
  - public double[] reverseEach(Closure<?> closure)
    
    Iterates through a double[] in reverse order passing each double to the given closure.
```
 double[] array = [0, 1, 2]
 String result = ''
 array.reverseEach{ result += it }
 assert result == '2.01.00.0'
 
```
    Parameters:
    closure - the closure applied on each double
    Returns:
    the self array
    Since:
    5.0.0
  - public int size()
    
    Provides arrays with a size method similar to collections.
    Returns:
    the length of the array
    Since:
    1.0
  - public Stream<Double> stream()
    
    Returns a sequential Stream with the specified array as its source.
    Returns:
    a Stream for the array
    Since:
    2.5.0
  - public double sum()
    
    Sums the items in an array.
```
assert (1+2+3+4 as double) == ([1,2,3,4] as double[]).sum()
```
    Returns:
    The sum of all the items
    Since:
    2.4.2
  - public double sum(DoubleUnaryOperator operator)
    
    Calculates the sum of values found from applying the operator to members of the int array.
```
 int[] nums = [10, -20, 30]
 assert 20 == nums.sum{ n -> n }
 assert 60 == nums.sum{ n -> n.abs() }
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Parameters:
    operator - an operator that returns a double used for summing values
    Returns:
    the sum value of all values after applying the operator
    Since:
    5.0.0
  - public double sum(double initialValue)
    
    Sums the items in an array, adding the result to some initial value.
```
assert (5+1+2+3+4 as double) == ([1,2,3,4] as double[]).sum(5)
```
    Parameters:
    initialValue - the items in the array will be summed to this initial value
    Returns:
    The sum of all the items.
    Since:
    2.4.2
  - public double[] swap(int i, int j)
    
    Swaps two elements at the specified positions.
    Example:
```
 assert ([1, 3, 2, 4] as double[]) == ([1, 2, 3, 4] as double[]).swap(1, 2)
 
```
    Parameters:
    i - a position
    j - a position
    Returns:
    self
    Since:
    2.4.0
  - public double[] tail()
    
    Returns the items from the double array excluding the first item.
```
 double[] doubles = [10.0d, 20.0d, 30.0d]
 def result = doubles.tail()
 assert result == [20.0d, 30.0d]
 assert doubles.class.componentType == result.class.componentType
 
```
    throws:
    UnsupportedOperationException if the array is empty
    
    Returns:
    an array without its first element
    Since:
    5.0.0
  - public List<Double> toList()
    
    Converts this array to a List of the same size, with each element added to the list.
    Returns:
    A list containing the contents of this array.
    Since:
    1.0
  - public Set<Double> toSet()
    
    Converts this array to a Set, with each unique element added to the set.
```
 double[] array = [1.0d, 2.0d, 3.0d, 2.0d, 1.0d]
 Set expected = [1.0d, 2.0d, 3.0d]
 assert array.toSet() == expected
 
```
    Returns:
    A set containing the unique contents of this array.
    Since:
    1.8.0
  - public String toString()
    
    Returns the string representation of the given array.
```
 double[] array = [1, 2, 3, 2, 1]
 assert array.toString() == '[1.0, 2.0, 3.0, 2.0, 1.0]'
 
```
    Returns:
    the string representation
    Since:
    1.6.0
  - public List<Tuple2<Double, Integer>> withIndex()
    
    Zips a double array with indices in (value, index) order.
    Example usage:
```
 double[] nums = [42.0d, -1.0d]
 assert [[42.0d, 0], [-1.0d, 1]] == nums.withIndex()
 assert ["0: 42.0", "1: -1.0"] == nums.withIndex().collect { n, idx -> "$idx: $n" }
 
```
    Returns:
    a zipped list with indices
    See Also:
    DefaultGroovyMethods#withIndex(Iterable)#withIndex(Iterable)
    Since:
    5.0.0
  - public List<Tuple2<Double, Integer>> withIndex(int offset)
    
    Zips a double array with indices in (value, index) order starting from a given index.
    Example usage:
```
 double[] nums = [42.0d, -1.0d]
 assert [[42.0d, 5], [-1.0d, 6]] == nums.withIndex(5)
 assert ["5: 42.0", "6: -1.0"] == nums.withIndex(5).collect { n, idx -> "$idx: $n" }
 
```
    Parameters:
    offset - an index to start from
    Returns:
    a zipped list with indices
    See Also:
    DefaultGroovyMethods#withIndex(Iterable)#withIndex(Iterable)
    Since:
    5.0.0
  - public List<Tuple2<Double, Double>> zip(double[] other)
    
    A list of all the pairs from two arrays.
```
 double[] small = [1.0d, 2.0d, 3.0d]
 double[] large = [100d, 200d, 300d]
 assert [small, large].transpose() == small.zip(large)
 
```
    Parameters:
    other - another double[]
    Returns:
    a list of all the pairs from self and other
    Since:
    5.0.0
  - public Iterator<Tuple2<Double, Double>> zipping(double[] other)
    
    An iterator of all the pairs from two arrays.
```
 double[] small = [1.0d, 2.0d, 3.0d]
 double[] large = [100d, 200d, 300d]
 assert [small, large].transpose() == small.zipping(large).toList()
 
```
    Parameters:
    other - another double[]
    Returns:
    an iterator of all the pairs from self and other
    Since:
    5.0.0

Summary:
Method

| Detail:
Method

[Java] Class double[]

Methods Summary

Inherited Methods Summary

Method Detail

public boolean any(Closure<?> predicate)

public boolean asBoolean()

public double average()

public List<List<Double>> chop(int chopSizes)

public boolean contains(Object value)

public Number count(Object value)

public DoubleStream doubleStream()

public double[] each(DoubleConsumer consumer)

public double[] eachWithIndex(Closure<?> closure)

public boolean equals(double[] right)

public boolean every(Closure<?> predicate)

public double first()

public List<Double> flatten()

public List<Double> getAt(Range<?> range)

public List<Double> getAt(IntRange range)

public List<Double> getAt(ObjectRange range)

public List<Double> getAt(Collection<?> indices)

public IntRange getIndices()

public String groovyToString()

public double head()

public Map<Integer, Double> indexed()

public Map<Integer, Double> indexed(int offset)

public double[] init()

public String join()

public String join(String separator)

public double last()

public double max()

public double max(DoubleComparator comparator)

public double max(DoubleUnaryOperator operator)

public double maxComparing(Comparator<Double> comparator)

public double min()

public double min(DoubleComparator comparator)

public double min(DoubleUnaryOperator operator)

public double minComparing(Comparator<Double> comparator)

public int partitionPoint(IntRange range, DoublePredicate condition)

public int partitionPoint(DoublePredicate condition)

public void putAt(IntRange range, double[] source)

public void putAt(IntRange range, Iterable<Number> source)

public double[] reverse()

public double[] reverse(boolean mutate)

public double[] reverseEach(Closure<?> closure)

public int size()

public Stream<Double> stream()

public double sum()

public double sum(DoubleUnaryOperator operator)

public double sum(double initialValue)

public double[] swap(int i, int j)

public double[] tail()

public List<Double> toList()

public Set<Double> toSet()

public String toString()

public List<Tuple2<Double, Integer>> withIndex()

public List<Tuple2<Double, Integer>> withIndex(int offset)

public List<Tuple2<Double, Double>> zip(double[] other)

public Iterator<Tuple2<Double, Double>> zipping(double[] other)